
#include "esp_log.h"
#include "esp_event.h"
#include "esp_lvgl_port.h"
#include "wifi_setting_ui.h"
#include "main_ui.h"
#include "md_images.h"
#include "md_languages.h"
#include "ui_setting.h"
#include "wifi_main.h"
#include "esp_smartconfig.h"
static const char *TAG = "wifi_setting_ui";
// 声明字体
LV_FONT_DECLARE(myFont);
LV_FONT_DECLARE(lv_font_montserrat_14);

static lv_obj_t *current_wifi_settings_screen = NULL;
static lv_obj_t *wifi_settings_screen_old = NULL;

static void scan_btn_event_cb(lv_event_t *e);        // 扫描按钮事件回调
static void smartconfig_btn_event_cb(lv_event_t *e); // 配网按钮事件回调
static void ble_btn_event_cb(lv_event_t *e);         // 蓝牙按钮事件回调

static bool is_wifi_screen=false; // 当前是否处于WiFi设置界面

void exit_wifi_setting_ui(lv_obj_t *root)
{
    if (is_wifi_screen) {
        switch_to_main_screen(); // 切换到主界面
        lv_obj_del(root);
    }
}
// 手势事件回调
static void event_handler(lv_event_t *e)
{

        lv_event_code_t code = lv_event_get_code(e);

        if (code == LV_EVENT_GESTURE) {
            lv_indev_t *indev = lv_indev_get_act();
            if (!indev)
                return;

            lv_dir_t dir = lv_indev_get_gesture_dir(indev);

            // 保留右划检测
            if (dir == LV_DIR_RIGHT || dir == LV_DIR_TOP) {
                exit_wifi_setting_ui(e->target);
            }
        }

}


// 刷新设置界面函数
static void refresh_wifi_settings_ui()
{
    wifi_settings_screen_old = current_wifi_settings_screen;

    // 创建新界面
    lv_obj_t *new_screen = create_wifi_ui();
    if (new_screen) {
        // 加载新界面
        lv_scr_load(new_screen);
        // 删除旧界面
        lv_obj_del(wifi_settings_screen_old);
        wifi_settings_screen_old = NULL;
    }
}


/* 
 * @ brief:创建无线调试UI
*/
lv_obj_t *create_wifi_ui(void)
{
    // 创建根容器（全屏黑色背景）
    lv_obj_t *root = lv_obj_create(NULL);
    if (!root)
        return NULL;
        
    lv_obj_remove_style_all(root); // 移除所有默认样式
    lv_obj_set_size(root, LV_PCT(100), LV_PCT(100));
    uint32_t color = get_screen_color_val();
    lv_obj_set_style_bg_color(root, lv_color_hex(color), 0);
    lv_obj_set_style_bg_opa(root, LV_OPA_COVER, 0);
    lv_obj_set_style_pad_all(root, 10, 0); // 添加内边距
    lv_obj_add_event_cb(root, event_handler, LV_EVENT_GESTURE, NULL);

    // 创建功能列表
    lv_obj_t *list = lv_list_create(root);
    lv_obj_set_size(list, LV_PCT(100), LV_PCT(100));
    lv_obj_set_style_bg_color(list, lv_color_hex(color), LV_PART_MAIN);
    lv_obj_set_style_bg_opa(list, LV_OPA_70, LV_PART_MAIN);
    lv_obj_set_style_border_width(list, 0, LV_PART_MAIN);
    lv_obj_set_style_radius(list, 10, LV_PART_MAIN);
    lv_obj_set_style_text_font(list, &myFont, LV_PART_MAIN);
    lv_obj_set_style_text_color(list, get_btn_font_color(), LV_PART_MAIN);
    lv_obj_set_style_pad_all(list, 10, LV_PART_MAIN); // 列表内边距
    
    // 添加功能按钮 - 使用更明显的样式
    lv_obj_t *btn;

    // Wi-Fi扫描按钮
    btn = lv_list_add_btn(list, NULL, get_func_txt_data(FUNC_WIFI_SETTINGS, WIFI_SETTINGS_SCAN_NUM));
    lv_obj_set_style_bg_opa(btn, LV_OPA_COVER, LV_PART_MAIN);
    lv_obj_set_style_radius(btn, 8, LV_PART_MAIN);
    lv_obj_set_style_pad_all(btn, 15, LV_PART_MAIN); // 按钮内边距
    lv_obj_add_event_cb(btn, scan_btn_event_cb, LV_EVENT_CLICKED, NULL);
    lv_obj_set_style_bg_color(btn, lv_color_hex(color), LV_PART_MAIN);
    lv_obj_set_style_text_color(btn, get_btn_font_color(), LV_PART_MAIN);
    // SmartConfig按钮
    btn = lv_list_add_btn(list, NULL, "SmartConfig");
    lv_obj_set_style_bg_opa(btn, LV_OPA_COVER, LV_PART_MAIN);
    lv_obj_set_style_radius(btn, 8, LV_PART_MAIN);
    lv_obj_set_style_pad_all(btn, 15, LV_PART_MAIN);
    lv_obj_add_event_cb(btn, smartconfig_btn_event_cb, LV_EVENT_CLICKED, NULL);
    lv_obj_set_style_bg_color(btn, lv_color_hex(color), LV_PART_MAIN);
    lv_obj_set_style_text_color(btn, get_btn_font_color(), LV_PART_MAIN);
    // 蓝牙按钮
    btn = lv_list_add_btn(list, NULL, get_func_txt_data(FUNC_WIFI_SETTINGS, WIFI_SETTINGS_BLU_NUM));
    lv_obj_set_style_bg_opa(btn, LV_OPA_COVER, LV_PART_MAIN);
    lv_obj_set_style_radius(btn, 8, LV_PART_MAIN);
    lv_obj_set_style_pad_all(btn, 15, LV_PART_MAIN);
    lv_obj_add_event_cb(btn, ble_btn_event_cb, LV_EVENT_CLICKED, NULL);
    lv_obj_set_style_bg_color(btn, lv_color_hex(color), LV_PART_MAIN);
    lv_obj_set_style_text_color(btn, get_btn_font_color(), LV_PART_MAIN);
    
    //保存
    current_wifi_settings_screen = root;
    is_wifi_screen = true;
    return root;
}

/**********************************各个按钮事件回调函数定义************************************************************/
/******************************** 第5个图标 WiFi设置 应用程序*****************************************************************************/

// 定义各种界面对象
lv_obj_t *wifi_scan_page;     // WiFi扫描页面对象，用于显示附近的WiFi列表
lv_obj_t *wifi_password_page; // WiFi密码输入页面对象，用于输入选中WiFi的密码
lv_obj_t *wifi_connect_page;  // WiFi连接页面对象，用于显示连接状态（连接中/成功/失败）
lv_obj_t *obj_scan_title;     // WiFi扫描页面标题栏对象，通常包含返回按钮和标题
lv_obj_t *label_wifi_scan;    // WiFi扫描页面标签，用于显示状态如“扫描中...”或“X个WLAN”
lv_obj_t *wifi_list;          // WiFi列表对象（lv_list），显示扫描到的WiFi名称
lv_obj_t *label_wifi_connect; // WiFi连接页面标签，用于显示“连接中...”等状态
lv_obj_t *ta_pass_text;       // 密码输入文本框（lv_textarea），用户在此输入密码
lv_obj_t *roller_num;         // 数字选择器（lv_roller），用于选择数字0-9作为密码
lv_obj_t *roller_letter_low;  // 小写字母选择器，用于选择小写字母a-z作为密码
lv_obj_t *roller_letter_up;   // 大写字母选择器，用于选择大写字母A-Z作为密码
lv_obj_t *label_wifi_name;    // WiFi名称标签，在密码输入页面显示当前选中的WiFi名

#define DEFAULT_SCAN_LIST_SIZE 5 // 定义最大扫描WiFi个数，即ap_info数组的大小

// WiFi账号队列，用于在任务间传递WiFi名称和密码
static QueueHandle_t xQueueWifiAccount = NULL;
// 队列要传输的内容结构体
typedef struct {
    char wifi_ssid[32];     // WiFi名称（SSID）
    char wifi_password[64]; // WiFi密码
    char back_flag;         // 是否退出标志。1表示退出连接任务，0表示正常连接
} wifi_account_t;

// 密码选择器（Roller）的遮罩显示效果事件处理函数
// 用于在Roller上下边缘创建渐变遮罩，使其看起来有“选中项突出，边缘淡化”的效果
static void mask_event_cb(lv_event_t *e)
{
    lv_event_code_t code = lv_event_get_code(e); // 获取事件代码
    lv_obj_t *obj = lv_event_get_target(e);      // 获取触发事件的对象

    static int16_t mask_top_id = -1;    // 顶部遮罩的ID
    static int16_t mask_bottom_id = -1; // 底部遮罩的ID

    if (code == LV_EVENT_COVER_CHECK) {
        // 事件：检查覆盖物。告知LVGL该对象已被遮罩覆盖
        lv_event_set_cover_res(e, LV_COVER_RES_MASKED);
    } else if (code == LV_EVENT_DRAW_MAIN_BEGIN) {
        /* 在主绘制开始前，添加遮罩 */
        const lv_font_t *font = lv_obj_get_style_text_font(obj, LV_PART_MAIN);       // 获取对象的字体
        lv_coord_t line_space = lv_obj_get_style_text_line_space(obj, LV_PART_MAIN); // 获取行间距
        lv_coord_t font_h = lv_font_get_line_height(font);                           // 计算字体的行高

        lv_area_t roller_coords;
        lv_obj_get_coords(obj, &roller_coords); // 获取Roller对象的坐标区域

        lv_area_t rect_area;
        // 计算顶部遮罩区域：从Roller顶部到中间偏上（减去字体高度和行间距的一半）
        rect_area.x1 = roller_coords.x1;
        rect_area.x2 = roller_coords.x2;
        rect_area.y1 = roller_coords.y1;
        rect_area.y2 = roller_coords.y1 + (lv_obj_get_height(obj) - font_h - line_space) / 2;

        // 创建并初始化一个淡入遮罩参数（从完全透明到不透明）
        lv_draw_mask_fade_param_t *fade_mask_top = lv_mem_buf_get(sizeof(lv_draw_mask_fade_param_t));
        lv_draw_mask_fade_init(fade_mask_top, &rect_area, LV_OPA_TRANSP, rect_area.y1, LV_OPA_COVER, rect_area.y2);
        mask_top_id = lv_draw_mask_add(fade_mask_top, NULL); // 添加遮罩到绘制掩码链表

        // 计算底部遮罩区域：从中间偏下到Roller底部
        rect_area.y1 = rect_area.y2 + font_h + line_space - 1;
        rect_area.y2 = roller_coords.y2;

        // 创建并初始化一个淡出遮罩参数（从不透明到完全透明）
        lv_draw_mask_fade_param_t *fade_mask_bottom = lv_mem_buf_get(sizeof(lv_draw_mask_fade_param_t));
        lv_draw_mask_fade_init(fade_mask_bottom, &rect_area, LV_OPA_COVER, rect_area.y1, LV_OPA_TRANSP, rect_area.y2);
        mask_bottom_id = lv_draw_mask_add(fade_mask_bottom, NULL); // 添加遮罩到绘制掩码链表

    } else if (code == LV_EVENT_DRAW_POST_END) {
        // 事件：主绘制结束后。移除遮罩并释放资源
        lv_draw_mask_fade_param_t *fade_mask_top = lv_draw_mask_remove_id(mask_top_id);
        lv_draw_mask_fade_param_t *fade_mask_bottom = lv_draw_mask_remove_id(mask_bottom_id);
        lv_draw_mask_free_param(fade_mask_top);
        lv_draw_mask_free_param(fade_mask_bottom);
        lv_mem_buf_release(fade_mask_top);    // 释放内存缓冲区
        lv_mem_buf_release(fade_mask_bottom); // 释放内存缓冲区
        mask_top_id = -1;                     // 重置ID
        mask_bottom_id = -1;                  // 重置ID
    }
}

// 数字键处理函数：当数字Roller的确认按钮被点击时调用
static void btn_num_cb(lv_event_t *e)
{
    lv_event_code_t code = lv_event_get_code(e); // 获取事件代码

    if (code == LV_EVENT_CLICKED) {
        ESP_LOGI(TAG, "Btn-Num Clicked");                         // 记录日志
        char buf[2];                                              // 缓冲区，用于接收选择器的当前选中值（一个数字字符+\0）
        lv_roller_get_selected_str(roller_num, buf, sizeof(buf)); // 获取Roller当前选中的字符串
        lv_textarea_add_text(ta_pass_text, buf);                  // 将选中的数字添加到密码文本框
    }
}

// 小写字母确认键处理函数：当小写字母Roller的确认按钮被点击时调用
static void btn_letter_low_cb(lv_event_t *e)
{
    lv_event_code_t code = lv_event_get_code(e);

    if (code == LV_EVENT_CLICKED) {
        ESP_LOGI(TAG, "Btn-Letter-Low Clicked");
        char buf[2]; // 接收选择器的值
        lv_roller_get_selected_str(roller_letter_low, buf, sizeof(buf));
        lv_textarea_add_text(ta_pass_text, buf); // 将选中的小写字母添加到密码文本框
    }
}

// 大写字母确认键处理函数：当大写字母Roller的确认按钮被点击时调用
static void btn_letter_up_cb(lv_event_t *e)
{
    lv_event_code_t code = lv_event_get_code(e);

    if (code == LV_EVENT_CLICKED) {
        ESP_LOGI(TAG, "Btn-Letter-Up Clicked");
        char buf[2]; // 接收选择器的值
        lv_roller_get_selected_str(roller_letter_up, buf, sizeof(buf));
        lv_textarea_add_text(ta_pass_text, buf); // 将选中的大写字母添加到密码文本框
    }
}

// 创建WiFi连接状态界面（连接中...）
static void lv_wifi_connect(void)
{
    lv_obj_del(wifi_password_page); // 首先删除密码输入界面

    // 创建一个全屏面板对象作为连接状态页面的容器
    static lv_style_t style;
    lv_style_init(&style);
    lv_style_set_bg_opa(&style, LV_OPA_COVER); // 设置背景不透明度为完全不透明
    lv_style_set_border_width(&style, 0);      // 无边框
    lv_style_set_pad_all(&style, 0);           // 内边距为0
    lv_style_set_radius(&style, 0);            // 无圆角
    lv_style_set_width(&style, 320);           // 宽度匹配屏幕
    lv_style_set_height(&style, 240);          // 高度匹配屏幕

    wifi_connect_page = lv_obj_create(lv_scr_act()); // 创建对象，并将其置于当前屏幕
    lv_obj_add_style(wifi_connect_page, &style, 0);  // 将样式应用于该对象
    lv_obj_center(wifi_connect_page);
    lv_obj_clear_flag(wifi_connect_page, LV_OBJ_FLAG_SCROLLABLE);// 禁止页面滚动
    // 创建并设置标签，显示连接状态
    label_wifi_connect = lv_label_create(wifi_connect_page);
    lv_label_set_text(label_wifi_connect, "WLAN连接中...");
    lv_obj_set_style_text_font(label_wifi_connect, &myFont, 0); // 使用自定义字体
    lv_obj_align(label_wifi_connect, LV_ALIGN_CENTER, 0, -50);  // 居中偏上显示
}

// WiFi连接按钮处理函数：当密码输入页面的"OK"按钮被点击时调用
static void btn_connect_cb(lv_event_t *e)
{
    lv_event_code_t code = lv_event_get_code(e);

    if (code == LV_EVENT_CLICKED) {
        ESP_LOGI(TAG, "OK Clicked");
        const char *wifi_ssid = lv_label_get_text(label_wifi_name);     // 获取之前存储的WiFi名称
        const char *wifi_password = lv_textarea_get_text(ta_pass_text); // 获取文本框中的密码
        if (*wifi_password != '\0')                                     // 判断密码是否为空字符串（第一个字符是否是结束符）
        {
            wifi_account_t wifi_account;
            strcpy(wifi_account.wifi_ssid, wifi_ssid);         // 拷贝SSID到结构体
            strcpy(wifi_account.wifi_password, wifi_password); // 拷贝密码到结构体
            ESP_LOGI(TAG, "connected to ap SSID:%s password:%s",
                     wifi_account.wifi_ssid, wifi_account.wifi_password); // 打印日志
            wifi_account.back_flag = 0;                                   // 设置标志位为0，表示正常连接请求
            lv_wifi_connect();                                            // 切换到“连接中...”界面
            // 将包含WiFi账号密码的结构体发送到队列，通知wifi_connect任务进行连接
            xQueueSend(xQueueWifiAccount, &wifi_account, portMAX_DELAY);
        }
        // 如果密码为空，这里没有处理，不会触发连接
    }
}

// 删除密码按钮处理函数：当密码输入页面的"退格"按钮被点击时调用
static void btn_del_cb(lv_event_t *e)
{
    lv_event_code_t code = lv_event_get_code(e);

    if (code == LV_EVENT_CLICKED) {
        ESP_LOGI(TAG, "Clicked");
        lv_textarea_del_char(ta_pass_text); // 删除密码文本框的最后一个字符
    }
}

// 返回按钮处理函数：当密码输入页面的"返回"按钮被点击时调用
static void btn_back_cb(lv_event_t *e)
{
    lv_event_code_t code = lv_event_get_code(e);

    if (code == LV_EVENT_CLICKED) {
        ESP_LOGI(TAG, "btn_back Clicked");
        lv_obj_del(wifi_password_page); // 删除密码输入界面，返回到之前的WiFi列表界面
    }
}
#define ROLLER_NUM_COLS 2 // 数字Roller的列数
// WiFi列表按钮事件处理函数：当WiFi列表中的某个WiFi按钮被点击时调用
static void list_btn_cb(lv_event_t *e)
{
    // 获取被点击的按钮对象和事件代码
    lv_event_code_t code = lv_event_get_code(e);
    lv_obj_t *obj = lv_event_get_target(e);
    const char *wifi_name = NULL;

    if (code == LV_EVENT_CLICKED) {
        // 根据按钮对象，从列表中获取对应的文本（WiFi名称）
        wifi_name = lv_list_get_btn_text(wifi_list, obj);
        ESP_LOGI(TAG, "WLAN Name: %s", wifi_name); // 记录选中的WiFi名称
    }

    // 创建密码输入页面
    wifi_password_page = lv_obj_create(lv_scr_act());
    lv_obj_set_size(wifi_password_page, 320, 240);           // 设置页面大小
    lv_obj_set_style_border_width(wifi_password_page, 0, 0); // 设置边框宽度为0
    lv_obj_set_style_pad_all(wifi_password_page, 0, 0);      // 设置内边距为0
    lv_obj_set_style_radius(wifi_password_page, 0, 0);       // 设置圆角为0
    lv_obj_center(wifi_password_page);
    lv_obj_clear_flag(wifi_password_page, LV_OBJ_FLAG_SCROLLABLE);

    // 创建返回按钮 (位于页面左上角)
    lv_obj_t *btn_back = lv_btn_create(wifi_password_page);
    lv_obj_align(btn_back, LV_ALIGN_TOP_LEFT, 0, 0);
    lv_obj_set_size(btn_back, 60, 40);
    lv_obj_set_style_border_width(btn_back, 0, 0);                      // 无边框
    lv_obj_set_style_pad_all(btn_back, 0, 0);                           // 无内边距
    lv_obj_set_style_bg_opa(btn_back, LV_OPA_TRANSP, LV_PART_MAIN);     // 背景透明
    lv_obj_set_style_shadow_opa(btn_back, LV_OPA_TRANSP, LV_PART_MAIN); // 阴影透明
    lv_obj_add_event_cb(btn_back, btn_back_cb, LV_EVENT_ALL, NULL);     // 绑定返回事件处理函数

    // 在返回按钮上创建一个标签，显示左箭头符号
    lv_obj_t *label_back = lv_label_create(btn_back);
    lv_label_set_text(label_back, LV_SYMBOL_LEFT);
    lv_obj_set_style_text_font(label_back, &lv_font_montserrat_14, 0);
    lv_obj_set_style_text_color(label_back, lv_color_hex(0x000000), 0);
    lv_obj_align(label_back, LV_ALIGN_TOP_LEFT, 10, 10);

    // 显示选中的WiFi名称 (位于页面顶部中间)
    label_wifi_name = lv_label_create(wifi_password_page);
    lv_obj_set_style_text_font(label_wifi_name, &lv_font_montserrat_14, 0);
    lv_label_set_text(label_wifi_name, wifi_name); // 设置文本为选中的WiFi名
    lv_obj_align(label_wifi_name, LV_ALIGN_TOP_MID, 0, 10);

    // 创建密码输入框
    ta_pass_text = lv_textarea_create(wifi_password_page);
    lv_obj_set_style_text_font(ta_pass_text, &lv_font_montserrat_14, 0);
    lv_textarea_set_one_line(ta_pass_text, true);               // 设置为单行模式
    lv_textarea_set_password_mode(ta_pass_text, false);         // 设置为非密码模式（明文显示）
    lv_textarea_set_placeholder_text(ta_pass_text, "password"); // 设置提示文本
    lv_obj_set_width(ta_pass_text, 150);                        // 设置宽度
    lv_obj_align(ta_pass_text, LV_ALIGN_TOP_LEFT, 10, 40);      // 设置位置
    lv_obj_add_state(ta_pass_text, LV_STATE_FOCUSED);           // 设置获得焦点状态（显示光标）

    // 创建"连接"按钮
    lv_obj_t *btn_connect = lv_btn_create(wifi_password_page);
    lv_obj_align(btn_connect, LV_ALIGN_TOP_LEFT, 170, 40);
    lv_obj_set_width(btn_connect, 65);                                    // 设置宽度
    lv_obj_add_event_cb(btn_connect, btn_connect_cb, LV_EVENT_ALL, NULL); // 绑定连接事件处理函数

    lv_obj_t *label_ok = lv_label_create(btn_connect);
    lv_label_set_text(label_ok, "OK");
    lv_obj_set_style_text_font(label_ok, &lv_font_montserrat_14, 0);
    lv_obj_center(label_ok); // 标签在按钮中居中

    // 创建"删除"按钮（用于退格）
    lv_obj_t *btn_del = lv_btn_create(wifi_password_page);
    lv_obj_align(btn_del, LV_ALIGN_TOP_LEFT, 245, 40);
    lv_obj_set_width(btn_del, 65);                                // 设置宽度
    lv_obj_add_event_cb(btn_del, btn_del_cb, LV_EVENT_ALL, NULL); // 绑定删除事件处理函数

    lv_obj_t *label_del = lv_label_create(btn_del);
    lv_label_set_text(label_del, LV_SYMBOL_BACKSPACE); // 显示退格符号
    lv_obj_set_style_text_font(label_del, &lv_font_montserrat_14, 0);
    lv_obj_center(label_del);

    // 创建选择器的通用样式
    static lv_style_t style;
    lv_style_init(&style);
    lv_style_set_bg_color(&style, lv_color_black());   // 背景黑色
    lv_style_set_text_color(&style, lv_color_white()); // 文字白色
    lv_style_set_border_width(&style, 0);
    lv_style_set_pad_all(&style, 0);
    lv_style_set_radius(&style, 0);

    // 创建"数字"选择器 (Roller)
    const char *opts_num = "0\n1\n2\n3\n4\n5\n6\n7\n8\n9"; // Roller的选项，用换行符分隔

    roller_num = lv_roller_create(wifi_password_page);
    lv_obj_add_style(roller_num, &style, 0);                          // 应用样式
    lv_obj_set_style_bg_opa(roller_num, LV_OPA_50, LV_PART_SELECTED); // 设置选中项的背景透明度

    lv_roller_set_options(roller_num, opts_num, LV_ROLLER_MODE_INFINITE); // 设置选项和无限滚动模式
    lv_roller_set_visible_row_count(roller_num, ROLLER_NUM_COLS);         // 设置可见行数为3行
    lv_roller_set_selected(roller_num, 5, LV_ANIM_OFF);                   // 默认选中第5项（'5'），无动画
    lv_obj_set_width(roller_num, 90);                                     // 设置宽度
    lv_obj_set_style_text_font(roller_num, &lv_font_montserrat_14, 0);    // 设置字体
    lv_obj_align(roller_num, LV_ALIGN_BOTTOM_LEFT, 15, -53);              // 定位到页面底部
    lv_obj_add_event_cb(roller_num, mask_event_cb, LV_EVENT_ALL, NULL);   // 添加遮罩效果事件

    // 创建"数字"选择器的确认键
    lv_obj_t *btn_num_ok = lv_btn_create(wifi_password_page);
    lv_obj_align(btn_num_ok, LV_ALIGN_BOTTOM_LEFT, 15, -10);         // 位置在Roller下方
    lv_obj_set_width(btn_num_ok, 90);                                // 宽度与Roller一致
    lv_obj_add_event_cb(btn_num_ok, btn_num_cb, LV_EVENT_ALL, NULL); // 绑定数字确认事件

    lv_obj_t *label_num_ok = lv_label_create(btn_num_ok);
    lv_label_set_text(label_num_ok, LV_SYMBOL_OK); // 显示对勾符号
    lv_obj_center(label_num_ok);
    lv_obj_set_style_text_font(label_num_ok, &lv_font_montserrat_14, 0);

    // 创建"小写字母"选择器
    const char *opts_letter_low = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz";

    roller_letter_low = lv_roller_create(wifi_password_page);
    lv_obj_add_style(roller_letter_low, &style, 0);
    lv_obj_set_style_bg_opa(roller_letter_low, LV_OPA_50, LV_PART_SELECTED);
    lv_roller_set_options(roller_letter_low, opts_letter_low, LV_ROLLER_MODE_INFINITE);
    lv_roller_set_visible_row_count(roller_letter_low, ROLLER_NUM_COLS);
    lv_roller_set_selected(roller_letter_low, 15, LV_ANIM_OFF); // 默认选中第15项（'p'）
    lv_obj_set_width(roller_letter_low, 90);
    lv_obj_set_style_text_font(roller_letter_low, &lv_font_montserrat_14, 0);
    lv_obj_align(roller_letter_low, LV_ALIGN_BOTTOM_LEFT, 115, -53); // 位于数字Roller右边
    lv_obj_add_event_cb(roller_letter_low, mask_event_cb, LV_EVENT_ALL, NULL);

    // 创建"小写字母"选择器的确认键
    lv_obj_t *btn_letter_low_ok = lv_btn_create(wifi_password_page);
    lv_obj_align(btn_letter_low_ok, LV_ALIGN_BOTTOM_LEFT, 115, -10);
    lv_obj_set_width(btn_letter_low_ok, 90);
    lv_obj_add_event_cb(btn_letter_low_ok, btn_letter_low_cb, LV_EVENT_ALL, NULL); // 绑定小写字母确认事件

    lv_obj_t *label_letter_low_ok = lv_label_create(btn_letter_low_ok);
    lv_label_set_text(label_letter_low_ok, LV_SYMBOL_OK);
    lv_obj_center(label_letter_low_ok);
    lv_obj_set_style_text_font(label_letter_low_ok, &lv_font_montserrat_14, 0);

    // 创建"大写字母"选择器
    const char *opts_letter_up = "A\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nU\nV\nW\nX\nY\nZ";

    roller_letter_up = lv_roller_create(wifi_password_page);
    lv_obj_add_style(roller_letter_up, &style, 0);
    lv_obj_set_style_bg_opa(roller_letter_up, LV_OPA_50, LV_PART_SELECTED);
    lv_roller_set_options(roller_letter_up, opts_letter_up, LV_ROLLER_MODE_INFINITE);
    lv_roller_set_visible_row_count(roller_letter_up, ROLLER_NUM_COLS);
    lv_roller_set_selected(roller_letter_up, 15, LV_ANIM_OFF); // 默认选中第15项（'P'）
    lv_obj_set_width(roller_letter_up, 90);
    lv_obj_set_style_text_font(roller_letter_up, &lv_font_montserrat_14, 0);
    lv_obj_align(roller_letter_up, LV_ALIGN_BOTTOM_LEFT, 215, -53); // 位于小写字母Roller右边
    lv_obj_add_event_cb(roller_letter_up, mask_event_cb, LV_EVENT_ALL, NULL);

    // 创建"大写字母"选择器的确认键
    lv_obj_t *btn_letter_up_ok = lv_btn_create(wifi_password_page);
    lv_obj_align(btn_letter_up_ok, LV_ALIGN_BOTTOM_LEFT, 215, -10);
    lv_obj_set_width(btn_letter_up_ok, 90);
    lv_obj_add_event_cb(btn_letter_up_ok, btn_letter_up_cb, LV_EVENT_ALL, NULL); // 绑定大写字母确认事件

    lv_obj_t *label_letter_up_ok = lv_label_create(btn_letter_up_ok);
    lv_label_set_text(label_letter_up_ok, LV_SYMBOL_OK);
    lv_obj_set_style_text_font(label_letter_up_ok, &lv_font_montserrat_14, 0);
    lv_obj_center(label_letter_up_ok);
}







// WiFi连接任务（在独立内核运行，处理连接逻辑）
static void wifi_connect(void *arg)
{
    wifi_account_t wifi_account; // 用于接收队列中的账号信息
    bool is_wifi_ok = false;
    while (true) {
        // 阻塞等待接收WiFi账号队列消息
        if (xQueueReceive(xQueueWifiAccount, &wifi_account, portMAX_DELAY)) {
            if (wifi_account.back_flag == 1) { // 检查是否为退出任务标志
                break;                         // 如果是，则跳出循环，准备删除任务
            }

            // 配置WiFi连接参数
            wifi_config_t wifi_config = {
                .sta = {
                    .threshold.authmode = WIFI_AUTH_WPA2_PSK, // 认证模式
                    .sae_pwe_h2e = WPA3_SAE_PWE_BOTH,         // WPA3相关设置
                    .sae_h2e_identifier = "",                 // WPA3标识符
                },
            };
            // 从队列消息中拷贝SSID和密码到配置结构体
            strcpy((char *)wifi_config.sta.ssid, wifi_account.wifi_ssid);
            strcpy((char *)wifi_config.sta.password, wifi_account.wifi_password);
            // 设置WiFi配置
            ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
            // 开始连接WiFi
            esp_wifi_connect();
            /* 等待连接结果事件：连接成功(WIFI_CONNECTED_BIT) 或 连接失败(WIFI_FAIL_BIT) */
            EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
                                                   WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
                                                   pdFALSE,        // 不清除位
                                                   pdFALSE,        // 不等待所有位
                                                   portMAX_DELAY); // 无限等待

            /* 判断具体是哪个事件发生了 */
            if (bits & WIFI_CONNECTED_BIT) {
                // 连接成功
                ESP_LOGI(TAG, "connected to ap SSID:%s password:%s", wifi_config.sta.ssid, wifi_config.sta.password);
                lvgl_port_lock(0);
                lv_label_set_text(label_wifi_connect, "WLAN 连接成功"); // 更新连接页面提示
                lvgl_port_unlock();
                vTaskDelay(1000 / portTICK_PERIOD_MS); // 延迟1秒，让用户看到成功提示
                lvgl_port_lock(0);
                is_wifi_screen=true; // 标记当前页面为WiFi设置页面
                lv_obj_del(wifi_connect_page); // 删除连接状态页面
                lv_obj_del(wifi_scan_page);    // 删除WiFi扫描列表页面
                lvgl_port_unlock();
                vQueueDelete(xQueueWifiAccount);                                                     // 删除队列

                is_wifi_ok=true;
                break; // 跳出循环，准备删除本任务
            } else if (bits & WIFI_FAIL_BIT) {
                // 连接失败（达到最大重试次数）
                ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s", wifi_config.sta.ssid, wifi_config.sta.password);
                lvgl_port_lock(0);
                lv_label_set_text(label_wifi_connect, "WLAN 连接失败"); // 更新连接页面提示
                lvgl_port_unlock();
                vTaskDelay(1000 / portTICK_PERIOD_MS); // 延迟1秒，让用户看到失败提示
                lvgl_port_lock(0);
                lv_obj_del(wifi_connect_page); // 删除连接状态页面，返回到密码输入页
                lvgl_port_unlock();
                xEventGroupClearBits(s_wifi_event_group, WIFI_FAIL_BIT); // 清除连接失败事件位，以便下次重试

            } else {
                // 发生了未预期的事件
                ESP_LOGE(TAG, "UNEXPECTED EVENT");
                lvgl_port_lock(0);
                lv_label_set_text(label_wifi_connect, "WLAN 连接异常");
                lvgl_port_unlock();
                vTaskDelay(1000 / portTICK_PERIOD_MS);
                lvgl_port_lock(0);
                lv_obj_del(wifi_connect_page); // 删除连接页面
                lv_obj_del(wifi_scan_page);    // 删除扫描页面，完全退出WiFi设置流程
                lvgl_port_unlock();
            }
        }
    }
    if (is_wifi_ok!=true)
    {
        wifiset_deinit(); // 清理WiFi初始化状态
    }
    vTaskDelete(NULL); // 任务结束，删除自身
}

// 返回主界面按钮事件处理函数（在WiFi扫描页面点击返回按钮时调用）
static void btn_backmain_cb(lv_event_t *e)
{
    ESP_LOGI(TAG, "btn_backmain Clicked");

    // 删除WiFi扫描界面
    lvgl_port_lock(0);
    lv_obj_del(wifi_scan_page);
    refresh_wifi_settings_ui(); // （假设）刷新设置UI，可能显示主设置菜单或返回桌面
    lvgl_port_unlock();

    // 构造一个退出标志消息，并通过队列发送给wifi_connect任务
    wifi_account_t wifi_account;
    wifi_account.back_flag = 1; // 设置退出标志
    xQueueSend(xQueueWifiAccount, &wifi_account, portMAX_DELAY);
    vTaskDelay(100 / portTICK_PERIOD_MS); // 延迟100ms，等待wifi_connect任务退出
   // wifiset_deinit();                // 清除WiFi扫描和连接相关的初始化痕迹
    vQueueDelete(xQueueWifiAccount); // 删除队列
}

// WiFi扫描和列表创建任务（在独立内核运行）
void app_wifi_connect(void *arg)
{
    vTaskDelay(200 / portTICK_PERIOD_MS); // 短暂延迟，可能等待界面稳定
    // 扫描WLAN信息
    wifi_ap_record_t ap_info[DEFAULT_SCAN_LIST_SIZE]; // 存储AP信息的数组
    uint16_t ap_number = DEFAULT_SCAN_LIST_SIZE;      // 输入：最大扫描数量；输出：实际找到的数量
    //先清除之前的WiFi设置

    esp_netif_t * sta_netif = wifi_scan(ap_info, &ap_number); // 执行WiFi扫描（此函数需在其他地方实现）

    lvgl_port_lock(0); // 操作LVGL前加锁
    // 修改扫描页面标题，显示找到的WiFi数量
    lv_label_set_text_fmt(label_wifi_scan, "%d WLAN", ap_number);

    // 在标题栏创建返回按钮（返回主界面，不是返回密码页）
    lv_obj_t *btn_back = lv_btn_create(obj_scan_title);
    lv_obj_align(btn_back, LV_ALIGN_LEFT_MID, 0, 0);
    lv_obj_set_size(btn_back, 60, 30);
    lv_obj_set_style_border_width(btn_back, 0, 0);
    lv_obj_set_style_pad_all(btn_back, 0, 0);
    lv_obj_set_style_bg_opa(btn_back, LV_OPA_TRANSP, LV_PART_MAIN);
    lv_obj_set_style_shadow_opa(btn_back, LV_OPA_TRANSP, LV_PART_MAIN);
    lv_obj_add_event_cb(btn_back, btn_backmain_cb, LV_EVENT_CLICKED, NULL); // 绑定返回主界面事件

    lv_obj_t *label_back = lv_label_create(btn_back);
    lv_label_set_text(label_back, LV_SYMBOL_LEFT);
    lv_obj_set_style_text_font(label_back, &lv_font_montserrat_14, 0);
    lv_obj_set_style_text_color(label_back, lv_color_hex(0xffffff), 0); // 白色箭头
    lv_obj_align(label_back, LV_ALIGN_CENTER, -10, 0);

    // 创建ListView组件用于显示WiFi列表
    wifi_list = lv_list_create(wifi_scan_page);
    lv_obj_set_size(wifi_list, 320, 200);                        // 设置列表大小
    lv_obj_align(wifi_list, LV_ALIGN_TOP_LEFT, 0, 40);           // 定位在标题栏下方
    lv_obj_set_style_border_width(wifi_list, 0, 0);              // 无边框
    lv_obj_set_style_text_font(wifi_list, &myFont, 0); // 使用自定义字体
    lv_obj_set_scrollbar_mode(wifi_list, LV_SCROLLBAR_MODE_OFF); // 隐藏滚动条

    // 遍历扫描结果，将每个WiFi添加到列表中
    lv_obj_t *btn;
    for (int i = 0; i < ap_number; i++) {
        ESP_LOGI(TAG, "SSID \t\t%s", ap_info[i].ssid); // 日志输出SSID
        ESP_LOGI(TAG, "RSSI \t\t%d", ap_info[i].rssi); // 日志输出信号强度
        // 向列表添加一个按钮，前缀为WiFi符号，文本为SSID
        btn = lv_list_add_btn(wifi_list, LV_SYMBOL_WIFI, (const char *)ap_info[i].ssid);
        lv_obj_add_event_cb(btn, list_btn_cb, LV_EVENT_CLICKED, NULL); // 绑定点击事件，进入密码页
    }
    lvgl_port_unlock(); // 操作完成，解锁LVGL

    // 创建WiFi连接任务（等待队列中的连接指令）
    xQueueWifiAccount = xQueueCreate(2, sizeof(wifi_account_t));                       // 创建队列，深度为2
    xTaskCreatePinnedToCore(wifi_connect, "wifi_connect", 4 * 1024, NULL, 5, NULL, 1); // 在Core 1创建任务
    vTaskDelete(NULL);                                                                 // 本任务完成，删除自身
}

// 提示任务函数：当检测到WiFi已连接时，显示提示并退出
static void wifiset_tips_task(void *pvParameters)
{
    // 显示提示信息
    lvgl_port_lock(0);
    label_wifi_scan = lv_label_create(wifi_scan_page);
    lv_label_set_text(label_wifi_scan, "WLAN 已连接");
    lv_obj_set_style_text_color(label_wifi_scan, lv_color_hex(0x000000), 0);
    lv_obj_set_style_text_font(label_wifi_scan, &myFont, 0);
    lv_obj_align(label_wifi_scan, LV_ALIGN_CENTER, 0, -50);
    lvgl_port_unlock();
    vTaskDelay(500 / portTICK_PERIOD_MS); // 显示0.5秒
    lvgl_port_lock(0);
    lv_obj_del(wifi_scan_page); // 删除提示页面
    lvgl_port_unlock();

    vTaskDelete(NULL); // 任务完成，删除自身
}

// 进入WiFi设置应用的主入口函数（点击WiFi设置图标时调用）
static void scan_btn_event_cb(lv_event_t *e)
{
    // 创建一个界面对象
    static lv_style_t style;
    lv_style_init(&style);
    lv_style_set_radius(&style, 10);
    lv_style_set_bg_opa(&style, LV_OPA_COVER);
    lv_style_set_bg_color(&style, lv_color_hex(0xFFFFFF));
    lv_style_set_border_width(&style, 0);
    lv_style_set_pad_all(&style, 0);
    lv_style_set_width(&style, 320);
    lv_style_set_height(&style, 240);

    wifi_scan_page = lv_obj_create(lv_scr_act());
    lv_obj_add_style(wifi_scan_page, &style, 0);
    lv_obj_center(wifi_scan_page);
    lv_obj_clear_flag(wifi_scan_page, LV_OBJ_FLAG_SCROLLABLE); // 禁止页面滚动  
    
    // 判断WiFi是否已连接
    int isconnect_flag = 1;         // 假设已连接
    if (s_wifi_event_group != NULL) // 如果WiFi事件组已创建
    {
        // 检查WIFI_CONNECTED_BIT事件位是否被置位（非阻塞检查）
        EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdFALSE, 10);
        if (bits & WIFI_CONNECTED_BIT) { // 如果已经连接到WiFi
            // 创建一个任务来显示"已连接"提示然后返回
            xTaskCreatePinnedToCore(wifiset_tips_task, "wifiset_tips_task", 2048, NULL, 5, NULL, 0);
        } else {
            isconnect_flag = 0; // 标记为未连接
        }
    }
    // 如果没有连接到WiFi（事件组不存在或事件位未置位），则正常进入扫描流程
    if (s_wifi_event_group == NULL || isconnect_flag == 0) {
        // 创建标题背景栏样式
        // 创建标题背景
        obj_scan_title = lv_obj_create(wifi_scan_page);
        lv_obj_set_size(obj_scan_title, 320, 40);
        lv_obj_set_style_pad_all(obj_scan_title, 0, 0); // 设置间隙
        lv_obj_align(obj_scan_title, LV_ALIGN_TOP_LEFT, 0, 0);
        lv_obj_set_style_bg_color(obj_scan_title, lv_color_hex(0x008b8b), 0);
        // 显示扫描情况
        label_wifi_scan = lv_label_create(obj_scan_title);
        lv_label_set_text(label_wifi_scan, "WLAN扫描中...");
        lv_obj_set_style_text_color(label_wifi_scan, lv_color_hex(0xffffff), 0);
        lv_obj_set_style_text_font(label_wifi_scan, &myFont, 0);
        lv_obj_align(label_wifi_scan, LV_ALIGN_CENTER, 0, 0);

        is_wifi_screen = false;
        xTaskCreatePinnedToCore(app_wifi_connect, "app_wifi_connect", 4 * 1024, NULL, 5, NULL, 0);
    }
}
/***********************************************SmartConfig****************************************************************/

static lv_obj_t *smartconfig_page = NULL;
static lv_obj_t *spinner = NULL;
static lv_obj_t *status_label = NULL;
static lv_obj_t *back_btn = NULL;

// 更新配网状态显示
static void update_smartconfig_status(const char *status)
{
    if (status_label) {
        lv_label_set_text(status_label, status);
    }


}

// 返回按钮事件回调
static void back_btn_event_cb(lv_event_t *e)
{
    lv_event_code_t code = lv_event_get_code(e);
    if (code == LV_EVENT_CLICKED) {
        // if (smartconfig_page) {
        //     lv_obj_del(smartconfig_page);
        //     smartconfig_page = NULL;
        // }
        // 删除smartconfig界面
        lvgl_port_lock(0);
        if (smartconfig_page)
            lv_obj_del(smartconfig_page);
        refresh_wifi_settings_ui(); // （假设）刷新设置UI，可能显示主设置菜单或返回桌面
        lvgl_port_unlock();
    }
}

// SmartConfig UI 任务
static void smartconfig_ui_task(void *parm)
{

    bool is_smartconfig_ok = false;
    // 创建页面样式
    lv_style_t style;
    lv_style_init(&style);
    lv_style_set_radius(&style, 10);
    lv_style_set_bg_opa(&style, LV_OPA_COVER);
    lv_style_set_bg_color(&style, lv_color_hex(0xFFFFFF));
    lv_style_set_border_width(&style, 0);
    lv_style_set_pad_all(&style, 0);
    lv_style_set_width(&style, 320);
    lv_style_set_height(&style, 240);
    lvgl_port_lock(0);
    // 创建页面
    smartconfig_page = lv_obj_create(lv_scr_act());
    lv_obj_add_style(smartconfig_page, &style, 0);
    lv_obj_center(smartconfig_page);
    lv_obj_clear_flag(smartconfig_page, LV_OBJ_FLAG_SCROLLABLE);

    // 创建标题
    lv_obj_t *title_label = lv_label_create(smartconfig_page);
    lv_label_set_text(title_label, "Wi-Fi 智能配网");
    lv_obj_set_style_text_font(title_label, &myFont, 0);
    lv_obj_set_style_text_color(title_label, lv_color_hex(0x000000), 0);
    lv_obj_align(title_label, LV_ALIGN_TOP_MID, 0, 20);

    // 创建加载 spinner
    spinner = lv_spinner_create(smartconfig_page, 1000, 60);
    lv_obj_set_size(spinner, 50, 50);
    lv_obj_align(spinner, LV_ALIGN_TOP_MID, 0, 70);
    lv_obj_set_style_arc_color(spinner, lv_color_hex(0x3498db), LV_PART_INDICATOR);

    // 创建状态标签
    status_label = lv_label_create(smartconfig_page);
    lv_label_set_text(status_label, "等待配网中...");
    lv_obj_set_style_text_color(status_label, lv_color_hex(0x000000), 0);
    lv_obj_align(status_label, LV_ALIGN_TOP_MID, 0, 130);



    // 创建返回按钮
    back_btn = lv_btn_create(smartconfig_page);
    lv_obj_set_size(back_btn, 100, 40);
    lv_obj_align(back_btn, LV_ALIGN_BOTTOM_MID, 0, -20);
    lv_obj_t *back_label = lv_label_create(back_btn);
    lv_label_set_text(back_label, "返回");
    lv_obj_center(back_label);
    lv_obj_add_event_cb(back_btn, back_btn_event_cb, LV_EVENT_CLICKED, NULL);

    // 初始状态下禁用返回按钮
    lv_obj_add_state(back_btn, LV_STATE_DISABLED);

    // 启动 SmartConfig
    update_smartconfig_status("正在启动配网...");

    lvgl_port_unlock();


    // 启动 SmartConfig
    esp_netif_t *sta_netif = wifi_smartconfig();

    if (sta_netif) {
        update_smartconfig_status("配网启动成功,等待连接...");

        // 等待 WiFi 连接成功
        EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
                                               WIFI_CONNECTED_BIT,
                                               pdFALSE,               // 不清除位
                                               pdFALSE,               // 不等待所有位
                                               pdMS_TO_TICKS(30000)); // 等待30秒

        if (bits & WIFI_CONNECTED_BIT) {
            // 等待 SmartConfig 完成
            bits = xEventGroupWaitBits(s_wifi_event_group,
                                       ESPTOUCH_DONE_BIT,
                                       pdTRUE,                // 清除位
                                       pdFALSE,               // 不等待所有位
                                       pdMS_TO_TICKS(20000)); // 等待20秒

            if (bits & ESPTOUCH_DONE_BIT) {
                // 配网成功
                update_smartconfig_status("配网成功!");
                lv_obj_del(spinner); // 移除 spinner

                // 显示成功图标
                lv_obj_t *success_icon = lv_label_create(smartconfig_page);
                lv_label_set_text(success_icon, LV_SYMBOL_OK);
                lv_obj_set_style_text_color(success_icon, lv_color_hex(0x00FF00), 0);
                lv_obj_set_style_text_font(success_icon, &lv_font_montserrat_14, 0);
                lv_obj_align(success_icon, LV_ALIGN_TOP_MID, 0, 70);
                is_smartconfig_ok = true;
                // 启用返回按钮
                lv_obj_clear_state(back_btn, LV_STATE_DISABLED);
            } else {
                // SmartConfig 超时
                update_smartconfig_status("配网超时,请重试");
                lv_obj_del(spinner); // 移除 spinner

                // 显示失败图标
                lv_obj_t *fail_icon = lv_label_create(smartconfig_page);
                lv_label_set_text(fail_icon, LV_SYMBOL_CLOSE);
                lv_obj_set_style_text_color(fail_icon, lv_color_hex(0xFF0000), 0);
                lv_obj_set_style_text_font(fail_icon, &lv_font_montserrat_14, 0);
                lv_obj_align(fail_icon, LV_ALIGN_TOP_MID, 0, 70);

                // 启用返回按钮
                lv_obj_clear_state(back_btn, LV_STATE_DISABLED);
            }
        } else {
            // WiFi 连接超时
            update_smartconfig_status("WiFi连接超时,请重试");
            lv_obj_del(spinner); // 移除 spinner

            // 显示失败图标
            lv_obj_t *fail_icon = lv_label_create(smartconfig_page);
            lv_label_set_text(fail_icon, LV_SYMBOL_CLOSE);
            lv_obj_set_style_text_color(fail_icon, lv_color_hex(0xFF0000), 0);
            lv_obj_set_style_text_font(fail_icon, &lv_font_montserrat_14, 0);
            lv_obj_align(fail_icon, LV_ALIGN_TOP_MID, 0, 70);

            // 启用返回按钮
            lv_obj_clear_state(back_btn, LV_STATE_DISABLED);
        }
    } else {
        // SmartConfig 启动失败
        update_smartconfig_status("配网启动失败,请重试");
        lv_obj_del(spinner); // 移除 spinner

        // 显示失败图标
        lv_obj_t *fail_icon = lv_label_create(smartconfig_page);
        lv_label_set_text(fail_icon, LV_SYMBOL_CLOSE);
        lv_obj_set_style_text_color(fail_icon, lv_color_hex(0xFF0000), 0);
        lv_obj_set_style_text_font(fail_icon, &lv_font_montserrat_14, 0);
        lv_obj_align(fail_icon, LV_ALIGN_TOP_MID, 0, 70);

        // 启用返回按钮
        lv_obj_clear_state(back_btn, LV_STATE_DISABLED);
    }
    //没有配网成功，删除wifi设置
    if (is_smartconfig_ok == false)
    {
        wifiset_deinit();
    }
        
    esp_smartconfig_stop();
    vTaskDelete(NULL); // 删除当前任务
}

// SmartConfig 按钮事件回调
static void smartconfig_btn_event_cb(lv_event_t *e)
{
    lv_event_code_t code = lv_event_get_code(e);
    if (code == LV_EVENT_CLICKED) {
        // 禁用按钮，防止重复点击
       // lv_obj_add_state(e->current_target, LV_STATE_DISABLED);
        // 创建智能配网任务
        xTaskCreate(smartconfig_ui_task, "smartconfig_ui_task", 1024*4, NULL, 3, NULL);
    }
}
// 蓝牙配网按钮事件回调
static void ble_btn_event_cb(lv_event_t *e)
{
    // lv_event_code_t code = lv_event_get_code(e);
    // if (code == LV_EVENT_CLICKED) {
    //     lv_label_set_text(status_label, "正在启动蓝牙配网...");

    //     // 这里添加实际的蓝牙配网启动代码
    //     // start_ble_provisioning();

    //     // 模拟蓝牙配网过程
    //     lv_timer_t *timer = lv_timer_create([](lv_timer_t *timer) {
    //         lv_label_set_text(status_label, "蓝牙配网已启动，等待连接...");
    //         lv_timer_del(timer);
    //     },
    //                                         3000, NULL);
    // }
}
